Métodos y atributos de los diferentes tipos de cadenas en python

En el presente trabajo se busca comenzar a explorar python mediate preguntas, yendo además de lo general a lo particular.

Primero se veran todos los métodos y atributos de las cadenas de caracteres(string), listas(list), tuplas(tuple) y conjuntos (set). Con el método dir(x), en donde x será alguna de las cadenas mencionadas anteriormente, se despliegan por orden alfabetico los métodos y atributos de x.

Definimos entonces similarmente las x:



In [19]:

    
palabra = 'aeiou'
lista = ['a','e','i','o','u']
tupla = ('a','e','i','o','u')
conjunto = {'a','e','i','o','u'}

Ahora mostramos todos los métodos y atributos de los objetos de arriba

Sería cómo preguntar ¿Cuales son los métodos y atributos de x? Se pregunta con dir(x)



In [20]:

    
print('Los metodos y atributos del objeto palabra son:', dir(palabra))









    



('Los metodos y atributos del objeto palabra son:', ['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill'])



In [21]:

    
print('Los metodos y atributos del objeto lista son:', dir(lista))









    



('Los metodos y atributos del objeto lista son:', ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'])



In [22]:

    
print('Los metodos y atributos del objeto tupla son:', dir(tupla))









    



('Los metodos y atributos del objeto tupla son:', ['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index'])



In [23]:

    
print('Los metodos y atributos del objeto conjunto son:', dir(conjunto))









    



('Los metodos y atributos del objeto conjunto son:', ['__and__', '__class__', '__cmp__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update'])

Ahora podríamos preguntar (aunque supuestamente ya lo sabemos) ¿que tipo de objeto son? con type(x), o bien si tendríamos alguna sospecha ¿es de tipo (P ej) string x?, con isinstance(string,x)



In [24]:

    
print(type(palabra), type(lista), type(tupla), type(conjunto))









    



(<type 'str'>, <type 'list'>, <type 'tuple'>, <type 'set'>)



In [25]:

    
isinstance(palabra,str)
#isinstance(lista,list)
#isinstance(tupla,tuple)
#isinstance(conjunto,set)









    Out[25]:





True

Ahora convirtamos las listas de arriba en conjuntos para pode hacer operaciones propias de los conjuntos (ya veremos cuales son) y poder comparar, cotejar y sacar conclusiones al respecto



In [26]:

    
metatr_str=set(dir(palabra))
metatr_lista=set(dir(lista))
metatr_tupla=set(dir(tupla))
metatr_conjunto=set(dir(conjunto))



In [27]:

    
print(metatr_str)









    



set(['upper', '__getslice__', 'startswith', 'lstrip', '__str__', '__getattribute__', 'rpartition', 'replace', 'isdigit', 'endswith', 'splitlines', 'rfind', 'strip', '__rmul__', '__lt__', '__getnewargs__', '__rmod__', '__init__', 'index', '__setattr__', '__reduce_ex__', '__new__', 'isalnum', '__contains__', 'rindex', 'capitalize', '__format__', '__class__', 'find', 'decode', 'isalpha', 'split', 'rstrip', 'encode', '_formatter_parser', 'translate', '__doc__', '__len__', '__repr__', '__ne__', '__getitem__', 'format', 'ljust', '__reduce__', 'rjust', 'swapcase', 'islower', '__subclasshook__', 'zfill', '__add__', '__gt__', '__eq__', '__sizeof__', 'count', 'lower', 'join', 'center', '__mod__', 'partition', 'rsplit', 'expandtabs', 'isspace', 'istitle', '__delattr__', '__le__', '__mul__', '_formatter_field_name_split', '__hash__', 'title', 'isupper', '__ge__'])

Podríamos preguntar ¿Cuáles son los métodos y atributos que son propios de una cadena de caracteres pero no de una lista? Esto sería algo así cómo lo que caracteriza a una cadena de caracteres



In [28]:

    
metatr_str - metatr_lista









    Out[28]:





{'__getnewargs__',
 '__mod__',
 '__rmod__',
 '_formatter_field_name_split',
 '_formatter_parser',
 'capitalize',
 'center',
 'decode',
 'encode',
 'endswith',
 'expandtabs',
 'find',
 'format',
 'isalnum',
 'isalpha',
 'isdigit',
 'islower',
 'isspace',
 'istitle',
 'isupper',
 'join',
 'ljust',
 'lower',
 'lstrip',
 'partition',
 'replace',
 'rfind',
 'rindex',
 'rjust',
 'rpartition',
 'rsplit',
 'rstrip',
 'split',
 'splitlines',
 'startswith',
 'strip',
 'swapcase',
 'title',
 'translate',
 'upper',
 'zfill'}

Podríamos preguntar ¿Cuales son los métodos y atributos comunes entre listas y strings? Sería algo así cómo lo que caracteriza a una cadena



In [29]:

    
metatr_str.intersection(metatr_lista)









    Out[29]:





{'__add__',
 '__class__',
 '__contains__',
 '__delattr__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__getslice__',
 '__gt__',
 '__hash__',
 '__init__',
 '__le__',
 '__len__',
 '__lt__',
 '__mul__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__rmul__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 'count',
 'index'}

Podemos recurrir al help de ipython para preguntar someramente que hace especificamente cada método o atributo:



In [30]:

    
help(palabra.find)









    



Help on built-in function find:

find(...)
    S.find(sub [,start [,end]]) -> int
    
    Return the lowest index in S where substring sub is found,
    such that sub is contained within S[start:end].  Optional
    arguments start and end are interpreted as in slice notation.
    
    Return -1 on failure.

Si queremos ver la diferencia entre una lista y una tupla:



In [31]:

    
metatr_lista - metatr_tupla









    Out[31]:





{'__delitem__',
 '__delslice__',
 '__iadd__',
 '__imul__',
 '__reversed__',
 '__setitem__',
 '__setslice__',
 'append',
 'extend',
 'insert',
 'pop',
 'remove',
 'reverse',
 'sort'}

Vemos que justamente una lista es una tupla que se puede modificar

Si queremos comparar una lista y un conjunto:



In [32]:

    
metatr_conjunto - metatr_lista









    Out[32]:





{'__and__',
 '__cmp__',
 '__iand__',
 '__ior__',
 '__isub__',
 '__ixor__',
 '__or__',
 '__rand__',
 '__ror__',
 '__rsub__',
 '__rxor__',
 '__sub__',
 '__xor__',
 'add',
 'clear',
 'copy',
 'difference',
 'difference_update',
 'discard',
 'intersection',
 'intersection_update',
 'isdisjoint',
 'issubset',
 'issuperset',
 'symmetric_difference',
 'symmetric_difference_update',
 'union',
 'update'}

Aqui podemos ver los métodos y atributos propios de un conjunto, los cuales podríamos explorar con el help(x)

Si hacemos la diferencia al revés, veremos que una lista tiene los métodos propios de un ordenn algo que no tiene un conjunto(), o incluso un diccionario, que también es un conjunto:



In [33]:

    
metatr_lista - metatr_conjunto









    Out[33]:





{'__add__',
 '__delitem__',
 '__delslice__',
 '__getitem__',
 '__getslice__',
 '__iadd__',
 '__imul__',
 '__mul__',
 '__reversed__',
 '__rmul__',
 '__setitem__',
 '__setslice__',
 'append',
 'count',
 'extend',
 'index',
 'insert',
 'reverse',
 'sort'}

También se podría seguir haciendo este tiṕo operaciones y sacando conclusiones y tratando de aprender así todos o casi todos los métodos y atributos de los objetos built-in o incluso incorporando objetos del módulo collections

Podemos también descubrir que existen cosas un tanto extrañas de python, dada la recursividad de dir(x):



In [34]:

    
dir(palabra.__add__)









    Out[34]:





['__call__',
 '__class__',
 '__cmp__',
 '__delattr__',
 '__doc__',
 '__format__',
 '__getattribute__',
 '__hash__',
 '__init__',
 '__name__',
 '__new__',
 '__objclass__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__self__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__']



In [35]:

    
dir(palabra.__add__.__call__)









    Out[35]:





['__call__',
 '__class__',
 '__cmp__',
 '__delattr__',
 '__doc__',
 '__format__',
 '__getattribute__',
 '__hash__',
 '__init__',
 '__name__',
 '__new__',
 '__objclass__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__self__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__']



In [36]:

    
dir(palabra.__add__.__call__.__cmp__)









    Out[36]:





['__call__',
 '__class__',
 '__cmp__',
 '__delattr__',
 '__doc__',
 '__format__',
 '__getattribute__',
 '__hash__',
 '__init__',
 '__name__',
 '__new__',
 '__objclass__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__self__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__']

Ver la posibilidad de explorar de lo general a lo particular es sumamente interesante, pues permite ver aspectos que yendo de lo particular a lo general no permite ver, abriendo formas de exploración y aprendizaje muchas veces completamente insospechadas pero que sin embargo creo altamente prometedoras.